Security News
Research
Data Theft Repackaged: A Case Study in Malicious Wrapper Packages on npm
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
@shopify/useful-types
Advanced tools
@shopify/useful-types
A few handy TypeScript types.
$ yarn add @shopify/useful-types
The following type aliases are provided by this library:
ThenType<T>
: When T
is a promise, resolves to the type the promise will resolve to (Promise<infer U>
). Otherwise, resolves to T
. Useful when you may or may not have a promise and need to reference the underlying type.
const value = 'foo';
const promise = Promise.resolve(value);
type V = ThenType<typeof value>; // string
type P = ThenType<typeof promise>; // string
ArgumentAtIndex<T, Index>
: Resolves to the type of the argument of the passed function at the passed index. Useful for cases where you wish to extract the type of arguments without actually exporting the argument types, and is a nice complement to TypeScript’s built-in ReturnType
.
const func = (foo: Promise<any>, bar: string) => foo.then(() => bar);
type Arg1 = ArgumentAtIndex<typeof func, 0>; // Promise<any>
type Arg2 = ArgumentAtIndex<typeof func, 1>; // string
type NotAnArg = ArgumentAtIndex<string, 0>; // never
FirstArgument<T>
: Resolves to the type of the first argument to the passed function. This is shorthand for ArgumentAtIndex<T, 0>
.
const func = (foo: Promise<any>) => foo.then(() => 'bar');
type Arg = FirstArgument<typeof func>; // Promise<any>
ConstructorArgumentAtIndex<T, Index>
: Resolves to the type of the argument of the passed class's constructor at the passed index. Useful for cases where you wish to extract the type of arguments without actually exporting the argument types, and is a nice complement to TypeScript’s built-in ReturnType
.
class SomeClass {
constructor(floop: string, doop: number) {
console.log(floop);
}
}
type DoopType = ConstructorArgument<typeof SomeClass, 1>; // number
FirstConstructorArgument<T>
: Resolves to the type of the first argument to the passed class's constructor. This is shorthand for ConstructorArgumentAtIndex<T, 0>
.
class SomeClass {
constructor(floop: string) {
console.log(floop);
}
}
type DoopType = FirstConstructorArgument<typeof SomeClass>; // string
ArrayElement<T>
: When T
is an array, resolves to the type contained within the array.
type FooArray = (string | number)[];
type Foo = ArrayElement<FooArray>; // string | number
Omit<T, K extends keyof T>
: The opposite of TypeScript’s Pick
type. Resolves to a new type that includes all keys in the original except those matching K
.
interface Obj {
foo: string;
bar: boolean;
baz: number;
}
type SelectiveObj = Omit<Obj, 'foo' | 'bar'>; // {baz: number}
DeepPartial<T>
: Recusively maps over all properties in a type and transforms them to be optional. Useful when you need to make optional all of the properties (and nested properties) of an existing type.
interface Obj {
foo: string;
bar: {
baz: boolean;
};
}
type DeepPartialObj = DeepPartial<Obj>; // {foo?: string; bar?: { baz?: boolean }}
NoInfer<T>
: creates a "lower priority inference site", which allows other uses of a generic to take precedence in inference.
// Here, TypeScript will always use the type of the items in the `items` argument as `T`, and will not consider the type of the `item` argument of `renderItem`.
function render<T>(items: T[], renderItem: (item: NoInfer<T>) => string) {
/* implementation */
}
DeepOmit<T, K>
Recursively maps over all properties in a type and omits those matching K
.
interface Obj {
__typename: string;
foo: string;
bar: {
__typename: string;
baz: string;
};
}
type SelectiveObj = DeepOmit<Obj, '__typename'>; // {foo: string; bar: {baz: string}}
DeepOmitArray<T extends any[], K>
Iterate over all properties in an array of types and omits those matching K
.
interface Obj {
__typename: string;
foo: string;
}
type SelectiveObj = DeepOmitArray<Obj[], '__typename'>; // {foo: string}[]
PartialSome<T, K extends keyof T>
Make specified keys K of T optional.
interface Obj {
foo: string;
bar: string;
}
type HalfPartialObj = PartialSome<Obj, 'foo'>; // {foo?: string, bar: string}
RequireSome<T, K extends keyof T>
Make specified keys K of T required.
interface Obj {
foo?: string;
bar?: string;
}
type HalfRequiredObj = RequireSome<Obj, 'foo'>; // {foo: string, bar?: string}
FAQs
A few handy TypeScript types
We found that @shopify/useful-types demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 24 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.
Security News
The Ultralytics' PyPI Package was compromised four times in one weekend through GitHub Actions cache poisoning and failure to rotate previously compromised API tokens.